GdkAtom
GDK_ATOM_TO_POINTER
GDK_POINTER_TO_ATOM
-GDK_NONE
gdk_text_property_to_utf8_list_for_display
gdk_utf8_to_string_target
gdk_atom_intern
device = GDK_DEVICE (device_core);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
}
static gboolean
static GdkAtom
gdk_broadway_drag_context_get_selection (GdkDragContext *context)
{
- g_return_val_if_fail (context != NULL, GDK_NONE);
+ g_return_val_if_fail (context != NULL, NULL);
- return GDK_NONE;
+ return NULL;
}
static gboolean
gint *ret_format)
{
if (ret_type)
- *ret_type = GDK_NONE;
+ *ret_type = NULL;
if (ret_format)
*ret_format = 0;
if (data)
*
* Returns the selection atom for the current source window.
*
- * Returns: (transfer none): the selection atom, or %GDK_NONE
+ * Returns: (transfer none): the selection atom, or %NULL
*/
GdkAtom
gdk_drag_get_selection (GdkDragContext *context)
{
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), GDK_NONE);
+ g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
return GDK_DRAG_CONTEXT_GET_CLASS (context)->get_selection (context);
}
* gdk_atom_intern:
* @atom_name: a string.
* @only_if_exists: if %TRUE, GDK is allowed to not create a new atom, but
- * just return %GDK_NONE if the requested atom doesn’t already
+ * just return %NULL if the requested atom doesn’t already
* exists. Currently, the flag is ignored, since checking the
* existance of an atom is as expensive as creating it.
*
gdk_atom_intern (const gchar *atom_name,
gboolean only_if_exists)
{
- g_return_val_if_fail (atom_name != NULL, GDK_NONE);
+ g_return_val_if_fail (atom_name != NULL, NULL);
return g_intern_string (atom_name);
}
GdkAtom
gdk_atom_intern_static_string (const gchar *atom_name)
{
- g_return_val_if_fail (atom_name != NULL, GDK_NONE);
+ g_return_val_if_fail (atom_name != NULL, NULL);
return g_intern_static_string (atom_name);
}
* @selection: selection that was requested.
* @target: target that was selected.
* @property: property in which the selection owner stored the
- * data, or %GDK_NONE to indicate that the request
+ * data, or %NULL to indicate that the request
* was rejected.
* @time_: timestamp.
*
gboolean send_event)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
- g_return_val_if_fail (selection != GDK_NONE, FALSE);
+ g_return_val_if_fail (selection != NULL, FALSE);
return GDK_DISPLAY_GET_CLASS (display)
->set_selection_owner (display, owner, selection, time, send_event);
GdkAtom selection)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
- g_return_val_if_fail (selection != GDK_NONE, NULL);
+ g_return_val_if_fail (selection != NULL, NULL);
return GDK_DISPLAY_GET_CLASS (display)->get_selection_owner (display, selection);
}
* @selection: selection that was requested
* @target: target that was selected
* @property: property in which the selection owner stored the data,
- * or %GDK_NONE to indicate that the request was rejected
+ * or %NULL to indicate that the request was rejected
* @time_: timestamp
*
* Send a response to SelectionRequest event.
{
GdkDisplay *display;
- g_return_if_fail (selection != GDK_NONE);
+ g_return_if_fail (selection != NULL);
display = gdk_window_get_display (requestor);
*/
#define GDK_POINTER_TO_ATOM(ptr) ((GdkAtom)(ptr))
-/**
- * GDK_NONE:
- *
- * A null value for #GdkAtom, used in a similar way as
- * `None` in the Xlib API.
- */
-#define GDK_NONE NULL
-
/* Forward declarations of commonly used types */
typedef struct _GdkRGBA GdkRGBA;
typedef struct _GdkCursor GdkCursor;
* gdk_property_get:
* @window: a #GdkWindow
* @property: the property to retrieve
- * @type: the desired property type, or %GDK_NONE, if any type of data
+ * @type: the desired property type, or %NULL, if any type of data
* is acceptable. If this does not match the actual
* type, then @actual_format and @actual_length will
* be filled in, a warning will be printed to stderr
*
* Retrieves a portion of the contents of a property. If the
* property does not exist, then the function returns %FALSE,
- * and %GDK_NONE will be stored in @actual_property_type.
+ * and %NULL will be stored in @actual_property_type.
*
* The XGetWindowProperty() function that gdk_property_get()
* uses has a very confusing and complicated set of semantics.
gdk_property_get (requestor,
gdk_atom_intern_static_string ("GDK_SELECTION"),
- GDK_NONE,
+ NULL,
0,
G_MAXULONG,
FALSE,
if (!out_size)
out_size = &best_size;
- *out_type = GDK_NONE;
+ *out_type = NULL;
*out_size = 0;
for (i = 0; i < n_formats; i++)
if (!actual_length)
actual_length = &dummy_actual_length;
- *actual_type = GDK_NONE;
+ *actual_type = NULL;
*actual_format = 0;
*actual_length = 0;
if (*actual_type == GDK_SELECTION_TYPE_ATOM || *actual_type == gdk_atom_intern_static_string ("ATOM_PAIR"))
*actual_format = 32;
- if (type != GDK_NONE && type != mir_property->type)
+ if (type != NULL && type != mir_property->type)
return FALSE;
offset *= 4;
for (i = 0; i < n_requested_targets; i++)
{
- if (requested_targets[i] == GDK_NONE)
+ if (requested_targets[i] == NULL)
continue;
mir_property = g_hash_table_lookup (impl->properties, requested_targets[i]);
device = GDK_DEVICE (quartz_device_core);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
}
static gboolean
gdk_quartz_drag_context_get_selection (GdkDragContext *context)
{
/* FIXME: Implement */
- return GDK_NONE;
+ return NULL;
}
static gboolean
{
gpointer result;
gchar *name;
- g_return_val_if_fail (atom_name != NULL, GDK_NONE);
+ g_return_val_if_fail (atom_name != NULL, NULL);
ensure_atom_tables ();
device = GDK_DEVICE (device_core);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
}
static gint
_gdk_wayland_display_deliver_event (seat->display, event);
- if (seat->pending_selection != GDK_NONE)
+ if (seat->pending_selection != NULL)
{
emit_selection_owner_change (seat->keyboard_focus,
seat->pending_selection);
- seat->pending_selection = GDK_NONE;
+ seat->pending_selection = NULL;
}
}
g_object_freeze_notify (G_OBJECT (tablet->current_device));
_gdk_device_reset_axes (tablet->current_device);
- _gdk_device_add_axis (tablet->current_device, GDK_NONE, GDK_AXIS_X, 0, 0, 0);
- _gdk_device_add_axis (tablet->current_device, GDK_NONE, GDK_AXIS_Y, 0, 0, 0);
+ _gdk_device_add_axis (tablet->current_device, NULL, GDK_AXIS_X, 0, 0, 0);
+ _gdk_device_add_axis (tablet->current_device, NULL, GDK_AXIS_Y, 0, 0, 0);
if (tool->tool_axes & (GDK_AXIS_FLAG_XTILT | GDK_AXIS_FLAG_YTILT))
{
- axis_pos = _gdk_device_add_axis (tablet->current_device, GDK_NONE,
+ axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
GDK_AXIS_XTILT, -90, 90, 0);
tablet->axis_indices[GDK_AXIS_XTILT] = axis_pos;
- axis_pos = _gdk_device_add_axis (tablet->current_device, GDK_NONE,
+ axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
GDK_AXIS_YTILT, -90, 90, 0);
tablet->axis_indices[GDK_AXIS_YTILT] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_DISTANCE)
{
- axis_pos = _gdk_device_add_axis (tablet->current_device, GDK_NONE,
+ axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
GDK_AXIS_DISTANCE, 0, 65535, 0);
tablet->axis_indices[GDK_AXIS_DISTANCE] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_PRESSURE)
{
- axis_pos = _gdk_device_add_axis (tablet->current_device, GDK_NONE,
+ axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
GDK_AXIS_PRESSURE, 0, 65535, 0);
tablet->axis_indices[GDK_AXIS_PRESSURE] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_ROTATION)
{
- axis_pos = _gdk_device_add_axis (tablet->current_device, GDK_NONE,
+ axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
GDK_AXIS_ROTATION, 0, 360, 0);
tablet->axis_indices[GDK_AXIS_ROTATION] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_SLIDER)
{
- axis_pos = _gdk_device_add_axis (tablet->current_device, GDK_NONE,
+ axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
GDK_AXIS_SLIDER, -65535, 65535, 0);
tablet->axis_indices[GDK_AXIS_SLIDER] = axis_pos;
}
seat->foreign_dnd_window = create_foreign_dnd_window (display);
seat->wl_seat = wl_seat;
- seat->pending_selection = GDK_NONE;
+ seat->pending_selection = NULL;
wl_seat_add_listener (seat->wl_seat, &seat_listener, seat);
wl_seat_set_user_data (seat->wl_seat, seat);
GdkAtom atom;
guint i;
- if (target == GDK_NONE)
+ if (target == NULL)
return FALSE;
for (i = 0; i < wayland_selection->source_targets->len; i++)
event->selection.send_event = FALSE;
event->selection.selection = selection;
event->selection.target = target;
- event->selection.property = GDK_NONE;
+ event->selection.property = NULL;
event->selection.time = GDK_CURRENT_TIME;
event->selection.requestor = g_object_ref (requestor);
{
GdkWaylandSelection *wayland_selection = gdk_wayland_display_get_selection (display);
- wayland_selection->requested_target = GDK_NONE;
+ wayland_selection->requested_target = NULL;
g_array_set_size (wayland_selection->source_targets, 0);
gdk_wayland_selection_unset_data_source (display, selection);
}
device = GDK_DEVICE (device_win32);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
}
if (device->pktdata & PK_X)
{
_gdk_device_add_axis (GDK_DEVICE (device),
- GDK_NONE,
+ NULL,
GDK_AXIS_X,
axis_x.axMin,
axis_x.axMax,
if (device->pktdata & PK_Y)
{
_gdk_device_add_axis (GDK_DEVICE (device),
- GDK_NONE,
+ NULL,
GDK_AXIS_Y,
axis_y.axMin,
axis_y.axMax,
if (device->pktdata & PK_NORMAL_PRESSURE)
{
_gdk_device_add_axis (GDK_DEVICE (device),
- GDK_NONE,
+ NULL,
GDK_AXIS_PRESSURE,
axis_npressure.axMin,
axis_npressure.axMax,
* we convert to x and y tilt in the -1000..1000 range
*/
_gdk_device_add_axis (GDK_DEVICE (device),
- GDK_NONE,
+ NULL,
GDK_AXIS_XTILT,
-1000,
1000,
1000);
_gdk_device_add_axis (GDK_DEVICE (device),
- GDK_NONE,
+ NULL,
GDK_AXIS_YTILT,
-1000,
1000,
if (cf == _cf_html_format || cf == _cf_text_html)
return _text_html;
- return GDK_NONE;
+ return NULL;
}
#endif
case GDK_DRAG_PROTO_OLE2:
return _gdk_ole2_dnd;
default:
- return GDK_NONE;
+ return NULL;
}
}
ATOM win32_atom;
gchar name[256];
- if (GDK_NONE == atom) return g_strdup ("<none>");
+ if (NULL == atom) return g_strdup ("<none>");
else if (GDK_SELECTION_PRIMARY == atom) return g_strdup ("PRIMARY");
else if (GDK_SELECTION_SECONDARY == atom) return g_strdup ("SECONDARY");
else if (GDK_SELECTION_CLIPBOARD == atom) return g_strdup ("CLIPBOARD");
HWND hwnd;
GdkEvent tmp_event;
- g_return_val_if_fail (selection != GDK_NONE, FALSE);
+ g_return_val_if_fail (selection != NULL, FALSE);
GDK_NOTE (DND, {
gchar *sel_name = gdk_atom_name (selection);
{
GdkWindow *window;
- g_return_val_if_fail (selection != GDK_NONE, NULL);
+ g_return_val_if_fail (selection != NULL, NULL);
if (selection == GDK_SELECTION_CLIPBOARD)
{
HGLOBAL hdata;
GdkAtom property = _gdk_selection;
- g_return_if_fail (selection != GDK_NONE);
+ g_return_if_fail (selection != NULL);
g_return_if_fail (requestor != NULL);
if (GDK_WINDOW_DESTROYED (requestor))
32, (guchar *) targets,
ntargets * sizeof (GdkAtom));
else
- property = GDK_NONE;
+ property = NULL;
}
else if (selection == GDK_SELECTION_CLIPBOARD && target == _utf8_string)
{
}
}
else
- property = GDK_NONE;
+ property = NULL;
API_CALL (CloseClipboard, ());
}
}
}
else
- property = GDK_NONE;
+ property = NULL;
/* Generate a selection notify message so that we actually fetch the
* data (if property == _gdk_selection) or indicating failure (if
- * property == GDK_NONE).
+ * property == NULL).
*/
generate_selection_notify (requestor, selection, target, property, time);
}
/* Always fail on Win32. No COMPOUND_TEXT support. */
if (encoding)
- *encoding = GDK_NONE;
+ *encoding = NULL;
if (format)
*format = 0;
/* Always fail on Win32. No COMPOUND_TEXT support. */
if (encoding)
- *encoding = GDK_NONE;
+ *encoding = NULL;
if (format)
*format = 0;
device = GDK_DEVICE (device_core);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
- _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
+ _gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
}
static gboolean
if (valuator_label != None)
label = gdk_x11_xatom_to_atom_for_display (display, valuator_label);
else
- label = GDK_NONE;
+ label = NULL;
_gdk_device_add_axis (device, label, use, min, max, resolution);
GDK_NOTE (INPUT, g_message ("\n\taxis: %s %s", gdk_atom_name (label), use == GDK_AXIS_IGNORE ? "(ignored)" : "(used)"));
if (context->protocol == GDK_DRAG_PROTO_XDND)
return gdk_atom_intern_static_string ("XdndSelection");
else
- return GDK_NONE;
+ return NULL;
}
static gboolean
/**
* gdk_x11_atom_to_xatom_for_display:
* @display: (type GdkX11Display): A #GdkDisplay
- * @atom: A #GdkAtom, or %GDK_NONE
+ * @atom: A #GdkAtom, or %NULL
*
* Converts from a #GdkAtom to the X atom for a #GdkDisplay
- * with the same string value. The special value %GDK_NONE
+ * with the same string value. The special value %NULL
* is converted to %None.
*
* Returns: the X atom corresponding to @atom, or %None
g_return_val_if_fail (GDK_IS_DISPLAY (display), None);
- if (atom == GDK_NONE)
+ if (atom == NULL)
return None;
if (gdk_display_is_closed (display))
Atom xatom)
{
GdkX11Display *display_x11;
- GdkAtom virtual_atom = GDK_NONE;
+ GdkAtom virtual_atom = NULL;
- g_return_val_if_fail (GDK_IS_DISPLAY (display), GDK_NONE);
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
if (xatom == None)
- return GDK_NONE;
+ return NULL;
if (gdk_display_is_closed (display))
- return GDK_NONE;
+ return NULL;
display_x11 = GDK_X11_DISPLAY (display);
display = gdk_window_get_display (window);
xproperty = gdk_x11_atom_to_xatom_for_display (display, property);
- if (type == GDK_NONE)
+ if (type == NULL)
xtype = AnyPropertyType;
else
xtype = gdk_x11_atom_to_xatom_for_display (display, type);
GdkAtom target,
guint32 time)
{
- g_return_if_fail (selection != GDK_NONE);
+ g_return_if_fail (selection != NULL);
if (GDK_WINDOW_DESTROYED (requestor) || !GDK_WINDOW_IS_X11 (requestor))
return;
err:
if (ret_type)
- *ret_type = GDK_NONE;
+ *ret_type = NULL;
if (ret_format)
*ret_format = 0;
if (data)
xevent.requestor = GDK_WINDOW_XID (requestor);
xevent.selection = gdk_x11_atom_to_xatom_for_display (display, selection);
xevent.target = gdk_x11_atom_to_xatom_for_display (display, target);
- if (property == GDK_NONE)
+ if (property == NULL)
xevent.property = None;
else
xevent.property = gdk_x11_atom_to_xatom_for_display (display, property);
if (GDK_WINDOW_IS_MAPPED (window))
gdk_wmspec_change_state (modal, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_MODAL"),
- GDK_NONE);
+ NULL);
}
static void
if (GDK_WINDOW_IS_MAPPED (window))
gdk_wmspec_change_state (skips_taskbar, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_SKIP_TASKBAR"),
- GDK_NONE);
+ NULL);
}
static void
if (GDK_WINDOW_IS_MAPPED (window))
gdk_wmspec_change_state (skips_pager, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_SKIP_PAGER"),
- GDK_NONE);
+ NULL);
}
static void
GDK_WINDOW_STATE_ICONIFIED);
gdk_wmspec_change_state (TRUE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_HIDDEN"),
- GDK_NONE);
+ NULL);
}
}
gdk_window_show (window);
gdk_wmspec_change_state (FALSE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_HIDDEN"),
- GDK_NONE);
+ NULL);
}
else
{
0);
gdk_wmspec_change_state (FALSE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_HIDDEN"),
- GDK_NONE);
+ NULL);
}
}
/* Request stick during viewport scroll */
gdk_wmspec_change_state (TRUE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_STICKY"),
- GDK_NONE);
+ NULL);
/* Request desktop 0xFFFFFFFF */
memset (&xclient, 0, sizeof (xclient));
/* Request unstick from viewport */
gdk_wmspec_change_state (FALSE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_STICKY"),
- GDK_NONE);
+ NULL);
move_to_current_desktop (window);
}
{
gdk_wmspec_change_state (TRUE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_FULLSCREEN"),
- GDK_NONE);
+ NULL);
/* Actual XRandR layout may have change since we computed the fullscreen
* monitors in GDK_FULLSCREEN_ON_ALL_MONITORS mode.
*/
if (GDK_WINDOW_IS_MAPPED (window))
gdk_wmspec_change_state (FALSE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_FULLSCREEN"),
- GDK_NONE);
+ NULL);
else
gdk_synthesize_window_state (window,
if (setting)
gdk_wmspec_change_state (FALSE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_BELOW"),
- GDK_NONE);
+ NULL);
gdk_wmspec_change_state (setting, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_ABOVE"),
- GDK_NONE);
+ NULL);
}
else
gdk_synthesize_window_state (window,
if (setting)
gdk_wmspec_change_state (FALSE, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_ABOVE"),
- GDK_NONE);
+ NULL);
gdk_wmspec_change_state (setting, window,
gdk_atom_intern_static_string ("_NET_WM_STATE_BELOW"),
- GDK_NONE);
+ NULL);
}
else
gdk_synthesize_window_state (window,
}
target = gtk_drag_dest_find_target (widget, context, NULL);
- if (target == GDK_NONE || gdk_drag_context_get_suggested_action (context) == 0)
+ if (target == NULL || gdk_drag_context_get_suggested_action (context) == 0)
gdk_drag_status (context, 0, time);
else
{
GdkAtom target;
target = gtk_drag_dest_find_target (widget, context, NULL);
- if (target != GDK_NONE)
+ if (target != NULL)
{
gtk_drag_get_data (widget, context,
target,
GSList *clipboards;
GSList *tmp_list;
- if (selection == GDK_NONE)
+ if (selection == NULL)
selection = GDK_SELECTION_CLIPBOARD;
clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
GdkAtom
gtk_clipboard_get_selection (GtkClipboard *clipboard)
{
- g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), GDK_NONE);
+ g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), NULL);
return clipboard->selection;
}
* Returns the clipboard object for the given selection.
* Cut/copy/paste menu items and keyboard shortcuts should use
* the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection.
- * (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD
+ * (%NULL is supported as a synonym for GDK_SELECTION_CLIPBOARD
* for backwards compatibility reasons.)
* The currently-selected object or text should be provided on the clipboard
* identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items
* to the default clipboard, i.e. they copy the selection to what the
* user sees as the clipboard.
*
- * (Passing #GDK_NONE is the same as using `gdk_atom_intern
+ * (Passing #NULL is the same as using `gdk_atom_intern
* ("CLIPBOARD", FALSE)`.
*
* See the
gpointer user_data)
{
g_return_if_fail (clipboard != NULL);
- g_return_if_fail (target != GDK_NONE);
+ g_return_if_fail (target != NULL);
g_return_if_fail (callback != NULL);
GTK_CLIPBOARD_GET_CLASS (clipboard)->request_contents (clipboard,
WaitResults results;
g_return_val_if_fail (clipboard != NULL, NULL);
- g_return_val_if_fail (target != GDK_NONE, NULL);
+ g_return_val_if_fail (target != NULL, NULL);
results.data = NULL;
results.loop = g_main_loop_new (NULL, TRUE);
GSList *clipboards;
GSList *tmp_list;
- if (selection == GDK_NONE)
+ if (selection == NULL)
selection = GDK_SELECTION_CLIPBOARD;
clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
GdkAtom
gtk_clipboard_get_selection (GtkClipboard *clipboard)
{
- g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), GDK_NONE);
+ g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), NULL);
return clipboard->selection;
}
guint target_info;
GtkSelectionData selection_data;
- selection_data.selection = GDK_NONE;
+ selection_data.selection = NULL;
selection_data.data = NULL;
selection_data.length = -1;
selection_data.target = gdk_quartz_pasteboard_type_to_atom_libgtk_only (type);
{
GdkAtom target = gtk_drag_dest_find_target (widget, context, NULL);
- if (target == GDK_NONE)
+ if (target == NULL)
{
gtk_drag_finish (context, FALSE, FALSE, time);
return TRUE;
GList *tmp_source = NULL;
GList *source_targets;
- g_return_val_if_fail (GTK_IS_WIDGET (widget), GDK_NONE);
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), GDK_NONE);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+ g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
dragging_info = gdk_quartz_drag_context_get_dragging_info_libgtk_only (context);
pasteboard = [dragging_info draggingPasteboard];
target_list = gtk_drag_dest_get_target_list (widget);
if (target_list == NULL)
- return GDK_NONE;
+ return NULL;
source_targets = _gtk_quartz_pasteboard_types_to_atom_list ([pasteboard types]);
tmp_target = target_list->list;
}
g_list_free (source_targets);
- return GDK_NONE;
+ return NULL;
}
static gboolean
gboolean del,
guint32 time)
{
- GdkAtom target = GDK_NONE;
+ GdkAtom target = NULL;
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
target = gdk_atom_intern_static_string ("DELETE");
}
- if (target != GDK_NONE)
+ if (target != NULL)
{
GtkWidget *selection_widget = gtk_drag_get_ipc_widget_for_display (gdk_window_get_display (gdk_drag_context_get_source_window (context)));
{
GdkAtom target = gtk_drag_dest_find_target (widget, context, NULL);
- if (target == GDK_NONE)
+ if (target == NULL)
{
gtk_drag_finish (context, FALSE, FALSE, time);
return TRUE;
if (pair->target == target1 || pair->target == target2)
{
- selection_data.selection = GDK_NONE;
+ selection_data.selection = NULL;
selection_data.target = pair->target;
selection_data.data = NULL;
selection_data.length = -1;
gpointer data)
{
GtkDragSourceInfo *info = data;
- static GdkAtom null_atom = GDK_NONE;
+ static GdkAtom null_atom = NULL;
guint target_info;
if (!null_atom)
*
* Looks for a match between the supported targets of @context and the
* @dest_target_list, returning the first matching target, otherwise
- * returning %GDK_NONE. @dest_target_list should usually be the return
+ * returning %NULL. @dest_target_list should usually be the return
* value from gtk_drag_dest_get_target_list(), but some widgets may
* have different valid targets for different parts of the widget; in
* that case, they will have to implement a drag_motion handler that
* passes the correct target list to this function.
*
- * Returns: (transfer none): first target that the source offers
- * and the dest can accept, or %GDK_NONE
+ * Returns: (transfer none) (nullable): first target that the source offers
+ * and the dest can accept, or %NULL
*/
GdkAtom
gtk_drag_dest_find_target (GtkWidget *widget,
GList *tmp_source = NULL;
GtkWidget *source_widget;
- g_return_val_if_fail (GTK_IS_WIDGET (widget), GDK_NONE);
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), GDK_NONE);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+ g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
source_widget = gtk_drag_get_source_widget (context);
if (target_list == NULL)
target_list = gtk_drag_dest_get_target_list (widget);
if (target_list == NULL)
- return GDK_NONE;
+ return NULL;
tmp_target = target_list->list;
while (tmp_target)
tmp_target = tmp_target->next;
}
- return GDK_NONE;
+ return NULL;
}
{
GtkEntry *entry = GTK_ENTRY (widget);
GtkEntryPrivate *priv = entry->priv;
- GdkAtom target = GDK_NONE;
+ GdkAtom target = NULL;
if (priv->editable)
target = gtk_drag_dest_find_target (widget, context, NULL);
- if (target != GDK_NONE)
+ if (target != NULL)
gtk_drag_get_data (widget, context, target, time);
else
gtk_drag_finish (context, FALSE, FALSE, time);
new_position = gtk_entry_find_position (entry, x + priv->scroll_offset);
if (priv->editable &&
- gtk_drag_dest_find_target (widget, context, NULL) != GDK_NONE)
+ gtk_drag_dest_find_target (widget, context, NULL) != NULL)
{
source_widget = gtk_drag_get_source_widget (context);
suggested_action = gdk_drag_context_get_suggested_action (context);
widget = GTK_WIDGET (icon_view);
*suggested_action = 0;
- *target = GDK_NONE;
+ *target = NULL;
if (!icon_view->priv->dest_set)
{
*target = gtk_drag_dest_find_target (widget, context,
gtk_drag_dest_get_target_list (widget));
- if (*target == GDK_NONE)
+ if (*target == NULL)
return FALSE;
if (!gtk_icon_view_get_dest_item_at_pos (icon_view, x, y, &path, &pos))
GtkIconView *icon_view;
GtkTreePath *path;
GdkDragAction suggested_action = 0;
- GdkAtom target = GDK_NONE;
+ GdkAtom target = NULL;
GtkTreeModel *model;
gboolean drop_append_mode;
path = get_logical_destination (icon_view, &drop_append_mode);
- if (target != GDK_NONE && path != NULL)
+ if (target != NULL && path != NULL)
{
/* in case a motion had requested drag data, change things so we
* treat drag data receives as a drop.
/* Unset this thing */
gtk_icon_view_set_drag_dest_item (icon_view, NULL, GTK_ICON_VIEW_DROP_LEFT);
- if (target != GDK_NONE)
+ if (target != NULL)
{
gtk_drag_get_data (widget, context, target, time);
return TRUE;
target = gtk_drag_dest_find_target (list_box, context, NULL);
- if (target == GDK_NONE)
+ if (target == NULL)
return FALSE;
gtk_drag_get_data (list_box, context, target, time);
if (!sidebar->drag_data_received)
{
- if (gtk_selection_data_get_target (selection_data) != GDK_NONE &&
+ if (gtk_selection_data_get_target (selection_data) != NULL &&
info == DND_TEXT_URI_LIST)
{
gchar **uris;
GdkWindow *window;
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
- g_return_val_if_fail (selection != GDK_NONE, FALSE);
+ g_return_val_if_fail (selection != NULL, FALSE);
g_return_val_if_fail (widget == NULL || gtk_widget_get_realized (widget), FALSE);
g_return_val_if_fail (widget == NULL || gtk_widget_get_display (widget) == display, FALSE);
GdkDisplay *display;
g_return_val_if_fail (widget == NULL || gtk_widget_get_realized (widget), FALSE);
- g_return_val_if_fail (selection != GDK_NONE, FALSE);
+ g_return_val_if_fail (selection != NULL, FALSE);
if (widget)
display = gtk_widget_get_display (widget);
GList *lists;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (selection != GDK_NONE);
+ g_return_if_fail (selection != NULL);
gdk_selection_clear_targets (gtk_widget_get_display (widget), selection);
GtkTargetList *list;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (selection != GDK_NONE);
+ g_return_if_fail (selection != NULL);
list = gtk_selection_target_list_get (widget, selection);
gtk_target_list_add (list, target, 0, info);
guint n_targets;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (selection != GDK_NONE);
+ g_return_if_fail (selection != NULL);
g_return_if_fail (targets != NULL);
list = gtk_selection_target_list_get (widget, selection);
guint id;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- g_return_val_if_fail (selection != GDK_NONE, FALSE);
+ g_return_val_if_fail (selection != NULL, FALSE);
if (initialize)
gtk_selection_init ();
mult_atoms = NULL;
gdk_error_trap_push ();
- if (!gdk_property_get (info->requestor, property, GDK_NONE, /* AnyPropertyType */
+ if (!gdk_property_get (info->requestor, property, NULL, /* AnyPropertyType */
0, selection_max_size, FALSE,
&type, &format, &length, &mult_atoms))
{
requestor,
selection,
target,
- GDK_NONE,
+ NULL,
time);
g_free (mult_atoms);
g_slice_free (GtkIncrInfo, info);
gtk_selection_invoke_handler (widget, &data, time);
if (data.length < 0)
{
- info->conversions[i].property = GDK_NONE;
+ info->conversions[i].property = NULL;
continue;
}
}
if (info->num_conversions == 1 &&
- info->conversions[0].property == GDK_NONE)
+ info->conversions[0].property == NULL)
{
/* Reject the entire conversion */
gdk_selection_send_notify_for_display (gtk_widget_get_display (widget),
requestor,
selection,
target,
- GDK_NONE,
+ NULL,
time);
}
else
if (!tmp_list) /* no retrieval in progress */
return FALSE;
- if (property != GDK_NONE)
+ if (property != NULL)
length = gdk_selection_property_get (window, &buffer,
&type, &format);
else
length = 0; /* silence gcc */
- if (property == GDK_NONE || buffer == NULL)
+ if (property == NULL || buffer == NULL)
{
current_retrievals = g_list_remove_link (current_retrievals, tmp_list);
g_list_free (tmp_list);
/* structure will be freed in timeout */
- gtk_selection_retrieval_report (info, GDK_NONE, 0, NULL, -1, time);
+ gtk_selection_retrieval_report (info, NULL, 0, NULL, -1, time);
return TRUE;
}
doing memory allocation at every step. But its only guaranteed to
be a _lower bound_ (pretty useless!) */
- if (length == 0 || type == GDK_NONE) /* final zero length portion */
+ if (length == 0 || type == NULL) /* final zero length portion */
{
/* Info structure will be freed in timeout */
current_retrievals = g_list_remove_link (current_retrievals, tmp_list);
g_list_free (tmp_list);
gtk_selection_retrieval_report (info,
type, format,
- (type == GDK_NONE) ? NULL : info->buffer,
- (type == GDK_NONE) ? -1 : info->offset,
+ (type == NULL) ? NULL : info->buffer,
+ (type == NULL) ? -1 : info->offset,
info->notify_time);
}
else /* append on newly arrived data */
{
current_retrievals = g_list_remove_link (current_retrievals, tmp_list);
g_list_free (tmp_list);
- gtk_selection_retrieval_report (info, GDK_NONE, 0, NULL, -1, GDK_CURRENT_TIME);
+ gtk_selection_retrieval_report (info, NULL, 0, NULL, -1, GDK_CURRENT_TIME);
}
g_free (info->buffer);
GList *formats;
GdkAtom atom;
- g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), GDK_NONE);
- g_return_val_if_fail (mime_type != NULL && *mime_type != '\0', GDK_NONE);
- g_return_val_if_fail (function != NULL, GDK_NONE);
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
+ g_return_val_if_fail (mime_type != NULL && *mime_type != '\0', NULL);
+ g_return_val_if_fail (function != NULL, NULL);
formats = g_object_steal_qdata (G_OBJECT (buffer), serialize_quark ());
gchar *mime_type;
GdkAtom format;
- g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), GDK_NONE);
- g_return_val_if_fail (tagset_name == NULL || *tagset_name != '\0', GDK_NONE);
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
+ g_return_val_if_fail (tagset_name == NULL || *tagset_name != '\0', NULL);
if (tagset_name)
{
GList *formats;
GdkAtom atom;
- g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), GDK_NONE);
- g_return_val_if_fail (mime_type != NULL && *mime_type != '\0', GDK_NONE);
- g_return_val_if_fail (function != NULL, GDK_NONE);
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
+ g_return_val_if_fail (mime_type != NULL && *mime_type != '\0', NULL);
+ g_return_val_if_fail (function != NULL, NULL);
formats = g_object_steal_qdata (G_OBJECT (buffer), deserialize_quark ());
gchar *mime_type;
GdkAtom format;
- g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), GDK_NONE);
- g_return_val_if_fail (tagset_name == NULL || *tagset_name != '\0', GDK_NONE);
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
+ g_return_val_if_fail (tagset_name == NULL || *tagset_name != '\0', NULL);
if (tagset_name)
{
GList *formats;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- g_return_if_fail (format != GDK_NONE);
+ g_return_if_fail (format != NULL);
formats = g_object_steal_qdata (G_OBJECT (buffer), serialize_quark ());
GList *formats;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- g_return_if_fail (format != GDK_NONE);
+ g_return_if_fail (format != NULL);
formats = g_object_steal_qdata (G_OBJECT (buffer), deserialize_quark ());
gchar *format_name;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- g_return_if_fail (format != GDK_NONE);
+ g_return_if_fail (format != NULL);
formats = g_object_get_qdata (G_OBJECT (buffer), deserialize_quark ());
gchar *format_name;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
- g_return_val_if_fail (format != GDK_NONE, FALSE);
+ g_return_val_if_fail (format != NULL, FALSE);
formats = g_object_get_qdata (G_OBJECT (buffer), deserialize_quark ());
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (register_buffer), NULL);
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (content_buffer), NULL);
- g_return_val_if_fail (format != GDK_NONE, NULL);
+ g_return_val_if_fail (format != NULL, NULL);
g_return_val_if_fail (start != NULL, NULL);
g_return_val_if_fail (end != NULL, NULL);
g_return_val_if_fail (length != NULL, NULL);
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (register_buffer), FALSE);
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (content_buffer), FALSE);
- g_return_val_if_fail (format != GDK_NONE, FALSE);
+ g_return_val_if_fail (format != NULL, FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (length > 0, FALSE);
target = gtk_drag_dest_find_target (widget, context,
gtk_drag_dest_get_target_list (widget));
- if (target == GDK_NONE)
+ if (target == NULL)
{
/* can't accept any of the offered targets */
}
GtkTextView *text_view;
GtkTextViewPrivate *priv;
GtkTextIter drop_point;
- GdkAtom target = GDK_NONE;
+ GdkAtom target = NULL;
text_view = GTK_TEXT_VIEW (widget);
priv = text_view->priv;
if (gtk_text_iter_can_insert (&drop_point, priv->editable))
target = gtk_drag_dest_find_target (widget, context, NULL);
- if (target != GDK_NONE)
+ if (target != NULL)
gtk_drag_get_data (widget, context, target, time);
else
gtk_drag_finish (context, FALSE, FALSE, time);
GdkAtom *atoms;
gint n_atoms;
GList *list;
- GdkAtom target = GDK_NONE;
+ GdkAtom target = NULL;
copy_tags = FALSE;
g_free (atoms);
- if (target != GDK_NONE)
+ if (target != NULL)
{
gtk_drag_get_data (widget, context, target, time);
gtk_text_buffer_end_user_action (buffer);
GtkWidget *item;
};
-static GdkAtom dnd_target_atom_item = GDK_NONE;
-static GdkAtom dnd_target_atom_group = GDK_NONE;
+static GdkAtom dnd_target_atom_item = NULL;
+static GdkAtom dnd_target_atom_group = NULL;
static const GtkTargetEntry dnd_targets[] =
{
palette->priv->text_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
- if (dnd_target_atom_item == GDK_NONE)
+ if (dnd_target_atom_item == NULL)
{
dnd_target_atom_item = gdk_atom_intern_static_string (dnd_targets[0].target);
dnd_target_atom_group = gdk_atom_intern_static_string (dnd_targets[1].target);
gboolean can_drop = FALSE;
*suggested_action = 0;
- *target = GDK_NONE;
+ *target = NULL;
widget = GTK_WIDGET (tree_view);
*target = gtk_drag_dest_find_target (widget, context,
gtk_drag_dest_get_target_list (widget));
- if (*target == GDK_NONE)
+ if (*target == NULL)
{
return FALSE;
}
GtkTreeView *tree_view;
GtkTreePath *path;
GdkDragAction suggested_action = 0;
- GdkAtom target = GDK_NONE;
+ GdkAtom target = NULL;
TreeViewDragInfo *di;
GtkTreeModel *model;
gboolean path_down_mode;
path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
- if (target != GDK_NONE && path != NULL)
+ if (target != NULL && path != NULL)
{
/* in case a motion had requested drag data, change things so we
* treat drag data receives as a drop.
NULL,
GTK_TREE_VIEW_DROP_BEFORE);
- if (target != GDK_NONE)
+ if (target != NULL)
{
gtk_drag_get_data (widget, context, target, time);
return TRUE;
* }
*
* target = gtk_drag_dest_find_target (widget, context, NULL);
- * if (target == GDK_NONE)
+ * if (target == NULL)
* gdk_drag_status (context, 0, time);
* else
* {
void
selection_test_get_targets (GtkWidget *dialog, gint response, GtkWidget *tree_view)
{
- static GdkAtom targets_atom = GDK_NONE;
+ static GdkAtom targets_atom = NULL;
if (response != GTK_RESPONSE_APPLY)
{
return;
}
- if (targets_atom == GDK_NONE)
+ if (targets_atom == NULL)
targets_atom = gdk_atom_intern ("TARGETS", FALSE);
gtk_selection_convert (tree_view, GDK_SELECTION_PRIMARY, targets_atom,
{
int i;
- seltypes[SEL_TYPE_NONE] = GDK_NONE;
+ seltypes[SEL_TYPE_NONE] = NULL;
seltypes[APPLE_PICT] = gdk_atom_intern ("APPLE_PICT",FALSE);
seltypes[ATOM] = gdk_atom_intern ("ATOM",FALSE);
seltypes[ATOM_PAIR] = gdk_atom_intern ("ATOM_PAIR",FALSE);
{
guchar *buffer;
gint len;
- GdkAtom type = GDK_NONE;
+ GdkAtom type = NULL;
if (!selection_string)
{
name = gtk_entry_get_text (GTK_ENTRY(entry));
atom = gdk_atom_intern (name, FALSE);
- if (atom == GDK_NONE)
+ if (atom == NULL)
{
g_print("Could not create atom: \"%s\"\n",name);
return;
projects / gtk4.git / commitdiff